Performance-aware Component Composition for GPU-based systems

This thesis adresses issues associated with efficiently programming modern heterogeneousGPU-based systems, containing multicore CPUs and one or more programmable Graphics Processing Units (GPUs). We use ideas from component-based programming to address programming, performance and portability issues of these heterogeneous systems. Specifically, we present three approaches that all use the idea of having multiple implementations for each computation; performance is achieved/retained either a) by selecting a suitable implementation for each computation on a given platform or b) by dividing the computation work across different implementations running on CPU and GPU devices in parallel. In the first approach, we work on a skeleton programming library (SkePU) that provides high-level abstraction while making intelligent implementation selection decisions underneath either before or during the actual program execution. In the second approach, we develop a composition tool that parses extra information (metadata) from XML files, makes certain decisions offline, and, in the end, generates code for making the final decisions at runtime. The third approach is a framework that uses source-code annotations and program analysis to generate code for the runtime library to make the selection decision at runtime. With a generic performance modeling API alongside program analysis capabilities, it supports online tuning as well as complex program transformations. These approaches differ in terms of genericity, intrusiveness, capabilities and knowledge about the program source-code; however, they all demonstrate usefulness of component programming techniques for programming GPU-based systems. With experimental evaluation, we demonstrate how all three approaches, although different in their own way, provide good performance on different GPU-based systems for a variety of applications. This work has been supported by two EU FP7 projects (PEPPHER, EXCESS) and by SeRC. “thesis” — 2014/4/2 — 13:08 — page iv — #4 Populärvetenskaplig sammanfattning Att f̊a varje generation av datorer att fungera snabbare är viktigt för samhällets utveckling och tillväxt. Traditionellt hade de flesta datorer bara en general-purpose processor (den s̊a kallade CPU:n) som bara kunde exekvera en beräkningsuppgift i taget. Under det senaste årtiondet har dock flerkärniga och mångkärniga processorer blivit vanliga, och datorer har ocks̊a blivit mer heterogena. Ett modernt datorsystem inneh̊aller vanligtvis fler än en CPU, tillsammans med specialprocessorer s̊asom grafikprocessorer (GPU:er) som är anpassade för att kunna exekvera vissa typer av beräkningar effektivare än CPU:er. Vi kallar ett s̊adant system med en eller flera GPU:er för ett GPU-baserat system. GPU:er i s̊adana system har sitt eget separata minne, och för att kunna köra en beräkning p̊a en GPU s̊a behöver man vanligtvis flytta all indata till GPU:ns minne och sedan hämta tillbaka resultatet när beräkningen är klar. Programmeringen av GPU-baserade system är icke-trivialt av flera anledningar: (1) CPU:er och GPU:er kräver olika programmeringsexpertis och verktyg, exempelvis kräver koden för en beräkning p̊a en GPU en helt annan struktur än samma beräkning p̊a en CPU. (2) Att snabba upp en beräkning kräver oftast speciella insatser för optimeringen av redan fungerande kod. I denna avhandling använder vi idéer fr̊an komponentbaserad programutveckling för att lösa programmeringsoch kodoptimeringsproblem för dessa system. Vi presenterar tre olika ansatser som alla använder idén att kunna välja mellan flera implementationer (varianter) för en och samma beräkning. I alla ansatserna uppn̊ar man bra prestanda genom att antingen: (a) välja den mest lämpliga implementationen bland de valbara varianterna för varje beräkningsuppgift i programmet för ett givet GPU-baserat system, eller (b) dela upp beräkningsarbetet mellan olika implementationer som exekverar p̊a CPU:er och GPU:er parallellt. Den ibland nödvändiga kommunikationen mellan de olika minnesmodulerna optimeras genom att flytta data enbart när det verkligen behövs, vilket avgörs först vid exekveringstid när man har den nödvändiga informationen till hands. De tre ansatserna är: 1. Ett skelettprogrammeringsbibliotek (SkePU) som tillhandah̊aller färdiga komponenter som programmeraren kan använda för att uttrycka beräkningar som matchar deras beräkningsstruktur. 2. Ett programkompositionsverktyg som tar in extra information om beräkningarna och deras olika implementationer i form av XML-filer, avgör vissa optimeringsbeslut redan före exekveringen, och slutligen genererar kod för att avgöra resterande optimeringar under programmets exekvering. “thesis” — 2014/4/2 — 13:08 — page v — #5 3. Ett ramverk som använder speciella kommentarer i källkoden och programanalys med hjälp av en kompilator för att analysera beräkningens struktur och generera lämplig kod för att optimera implementeringsurvalet vid exekveringstid. Dessa ansatser har olika egenskaper, exempelvis är den sistnämda ansatsen mer generisk än den första, medan den första kräver mindre programmeringsarbete. Änd̊a demonstrerar alla tre att den komponentbaserade programmeringstekniken gynnar en effektiv programmering av GPU-baserade system. Vi redovisar en omfattande experimentell utvärdering av varje ansats med flera applikationsprogram p̊a olika GPU-baserade system. De experimentella utvärderingen visar att varje ansats, trots uppenbara skillnader, leder till bra prestanda p̊a olika GPU-baserade system för ett spektrum av applikationer. “thesis” — 2014/4/2 — 13:08 — page vi — #6